//package com.leon.learnenginespace.drools.bl;
//
//import com.alibaba.fastjson.JSON;
//import com.alibaba.fastjson.JSONArray;
//import com.alibaba.fastjson.JSONObject;
//import com.leon.common.common.DateUtil;
//import com.leon.common.entity.RequestBodyVo;
//import com.leon.common.entity.ResponseVo;
//import com.leon.learnenginespace.drools.dao.CalculateMapper;
//import com.leon.learnenginespace.drools.dao.DictionaryMapper;
//import com.leon.learnenginespace.drools.dao.RuleMapper;
//import com.leon.learnenginespace.drools.pojo.*;
//import com.leon.learnenginespace.drools.utils.IdGeneratorSnowflake;
//import com.leon.learnenginespace.drools.utils.ModelEntity;
//import com.leon.learnenginespace.drools.utils.ParamException;
//import com.leon.learnenginespace.drools.utils.RuleUtils;
//import org.apache.commons.lang3.StringUtils;
//import org.apache.commons.logging.Log;
//import org.apache.commons.logging.LogFactory;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.beans.factory.annotation.Value;
//import org.springframework.stereotype.Component;
//import org.springframework.transaction.annotation.Transactional;
//
//import javax.crypto.Cipher;
//import javax.crypto.spec.SecretKeySpec;
//import java.nio.charset.StandardCharsets;
//import java.security.Security;
//import java.util.ArrayList;
//import java.util.Base64;
//import java.util.List;
//
///**
// * @description 规则管理-保存接口 数据处理
// * @author lhy
// * @data 2023年3月30日
// */
//@Component
//public class UpdateRuleBL {
//    private final Log logger = LogFactory.getLog(this.getClass());
//
//    @Value("${drools.ruleCenter.privateKey}")
//    private String privateKey;
//    @Autowired
//    RuleMapper ruleMapper;
//    @Autowired
//    RuleUtils ruleUtils;
//    @Autowired
//    DictionaryMapper dictionaryMapper;
//    @Autowired
//    CalculateMapper calculateMapper;
//    @Autowired
//    private IdGeneratorSnowflake idGenerator;
//
//    // 解决 Cannot find any provider supporting AES/ECB/PKCS7Padding
//    static {
////        Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
//    }
//
//    /**
//     * 解析报文体为实体类对象；更新到数据库中
//     * @param requestBody
//     * @return responseVo
//     */
//    @Transactional(rollbackFor = Exception.class)
//    public ResponseVo dealData(RequestBodyVo requestBody)  throws Exception{
//        logger.info("RD004规则保存接口 开始");
//        ResponseVo responseVo = updateRule(requestBody);
//        return responseVo;
//    }
//
//    /**
//     * 规则创建逻辑
//     * 1.判断是否有词条id
//     * 1.1如果没有走原逻辑
//     * 1.2如果有更新T_DRL_COUNT num+1，并获取num（<update> <selectKey after></selectKey></update>）
//     * 1.2.1 创建规则，调用RuleUtils.createRule,返回规则
//     * 1.2.2 保存规则
//     * 1.2.3 保存模式T_DRL_RULEMODEL_CONFIG
//     * 1.2.4 保存词条
//     * 1.2.5 保存计算表达式
//     * @param requestBody
//     * @return
//     */
//    @Transactional(rollbackFor = Exception.class)
//    public ResponseVo updateRule(RequestBodyVo requestBody)  throws Exception{
//        ResponseVo responseVo = new ResponseVo();
//        JSONObject body = (JSONObject) requestBody.getBody();
//        TDrlRuleConfi tDrlRuleConfig = JSONObject.parseObject(body.toJSONString(), TDrlRuleConfi.class);
//        int updateRow = 0;
//        tDrlRuleConfig.setCreatedTime(DateUtil.getCurDateTime());
//        tDrlRuleConfig.setUpdatedTime(DateUtil.getCurDateTime());
//        if (null == tDrlRuleConfig.getId() || "".equals(tDrlRuleConfig.getId())) {
//            updateRow = crateRule(tDrlRuleConfig);
//        } else {
//            updateRow = updateRule(tDrlRuleConfig);
//        }
//        if (updateRow > 0) {
//            responseVo.setValue(requestBody.getHeader(), "id", tDrlRuleConfig.getId(), null);
//        } else {
//            throw new ParamException("规则保存失败");
//        }
//        return responseVo;
//    }
//
//    /**
//     * 更新规则
//     * @param tDrlRuleConfig
//     * @return
//     */
//    public int updateRule(TDrlRuleConfi tDrlRuleConfig) throws Exception{
//        String fieldId = tDrlRuleConfig.getFieldId();
//        List<TDrlNRuleFieldConfig> fieldList = tDrlRuleConfig.getFieldList();
//        List<TDrlNRuleExpressionConfig> exList = tDrlRuleConfig.getExList();
//        int updateRow = 0;
//        // 规则内容 AES+BASE64 解密
//        String content = decrypt(tDrlRuleConfig.getContent(), privateKey);
//        logger.info("解密后的规则内容为：" + content);
//        tDrlRuleConfig.setContent(content);
//        ruleUtils.load(tDrlRuleConfig.getContent());
//        if ((null == fieldId || "".equals(fieldId))
//                && (null == fieldList || fieldList.size() == 0)
//                && (null == exList || exList.size() == 0)) {
//            // 无词条id及词条列表及计算表达式列表，可以更新。
//            updateRow = ruleMapper.tDrlRuleConfigUpdate(tDrlRuleConfig);
//        }else{
//            logger.info("词条或计算表达式创建的规则，禁更新。"+tDrlRuleConfig.getCode() );
//            throw new ParamException("词条或计算表达式创建的规则，禁更新,"+tDrlRuleConfig.getCode() +"。");
//        }
//        return updateRow;
//    }
//
//    /**
//     * 创建规则
//     * @param tDrlRuleConfig
//     * @return
//     */
//    public  int ruleConfigCreat(TDrlRuleConfi tDrlRuleConfig){
//        int ruleCodeNum = ruleMapper.queryRuleCode(tDrlRuleConfig);
//        if (ruleCodeNum >= 1) {
//            logger.info("该规则编码" + tDrlRuleConfig.getCode() + "已存在，不能重复添加。");
//            throw new ParamException("规则编码已存在，添加失败！");
//        }
//        tDrlRuleConfig.setId(String.valueOf(idGenerator.snowflakeId()));
//        return ruleMapper.tDrlRuleConfigCreat(tDrlRuleConfig);
//    }
//
//    /**
//     * AES解密ECB模式PKCS7Padding填充方式
//     * Base64
//     * @param str 字符串
//     * @param key 密钥
//     * @return 解密字符串
//     * @throws Exception 异常信息
//     */
//    public static String decrypt(String str, String key) throws Exception {
//        // AES
//        Cipher cipher = Cipher.getInstance("AES/ECB/PKCS7Padding");
//        byte[] keyBytes = key.getBytes(StandardCharsets.UTF_8);
//        cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(keyBytes, "AES"));
//        byte[] doFinal = cipher.doFinal(Base64.getDecoder().decode(str));
//        // Base64
//        byte[] decodedBytes = Base64.getDecoder().decode(doFinal);
//        String decodedContent = new String(decodedBytes);
//        return decodedContent;
//    }
//
//    /**
//     * 创建规则
//     * @param tDrlRuleConfig
//     * @return
//     */
//    private int crateRule(TDrlRuleConfi tDrlRuleConfig) throws Exception{
//        String fieldId = tDrlRuleConfig.getFieldId();
//        List<TDrlNRuleFieldConfig> fieldList = tDrlRuleConfig.getFieldList();
//        List<TDrlNRuleExpressionConfig> exList = tDrlRuleConfig.getExList();
//        int updateRow = 0;
//        List<ModelEntity> modelEntityList;
//
//        //判断是否有词条id、词条列表、计算表达式列表。三者皆无表示手动添加规则。
//        if ((null == fieldList || fieldList.size() == 0) && (null == exList || exList.size() == 0)
//                && (null == fieldId || "".equals(fieldId))) {
//            tDrlRuleConfig.setFieldId(null);
//            // 规则内容 AES+BASE64 解密
//            String content = decrypt(tDrlRuleConfig.getContent(), privateKey);
//            logger.info("解密后的规则内容为：" + content);
//            tDrlRuleConfig.setContent(content);
//            ruleUtils.load(tDrlRuleConfig.getContent());
//            updateRow = this.ruleConfigCreat(tDrlRuleConfig);
//        } else if((null == fieldList || fieldList.size() == 0) && (null == exList || exList.size() == 0)
//                && fieldId != null  &&  !"".equals(fieldId) ) {//单词条创建规则
//
//            TDrlDictionary dictionary = new TDrlDictionary();
//            if (!StringUtils.isEmpty(tDrlRuleConfig.getOperationType())) {
//                dictionary = this.queryDictionary("4", tDrlRuleConfig.getOperationType(), "运算符错误，在字典数据中无法找到！");
//            }
//
//            //更新规则编码序号num+1，并获取num。
//            Long num = getNum("FILELD");
//
//            //创建规则，调用RuleUtils.createRule,返回规则
//            TDrlFieldConfig fieldConfig = queryFiled(fieldId);
//            String value = tDrlRuleConfig.getValue();
//            modelEntityList = tDrlRuleConfig.getList();
//            modelSetDictionary(modelEntityList);
//            String warningInfo = tDrlRuleConfig.getWarningInfo();
//            String rule = ruleUtils.createRule(num, fieldConfig, value, dictionary, modelEntityList, warningInfo);
//            ruleUtils.load(rule);
//            tDrlRuleConfig.setContent(rule);
//            tDrlRuleConfig.setFieldId(fieldId);
//            tDrlRuleConfig.setCode("FIELD"+num);
//            tDrlRuleConfig.setType("1");
//
//            //保存规则
//            updateRow = this.ruleConfigCreat(tDrlRuleConfig);
//
//            //保存模式
//            if (modelEntityList != null) {
//                tDrlRuleModelConfigCreate(modelEntityList,fieldId);
//            }
//        } else {//多词条或计算表达式创建规则
//
//            CreateRuleModel createRuleModel = new CreateRuleModel();
//
//            //更新规则编码序号num+1，并获取num。
//            Long num = getNum("FILELD");
//            String warningInfo = tDrlRuleConfig.getWarningInfo();
//            modelEntityList = tDrlRuleConfig.getList();
//            createRuleModel.setRelationshipTypeCode(tDrlRuleConfig.getRelation());
//
//            //处理字典数据
//            modelSetDictionary(modelEntityList);
//            fieldSetDictionary(tDrlRuleConfig.getFieldList());
//            exPreSetDictionary(tDrlRuleConfig.getExList());
//            relationSetDictionary(createRuleModel, tDrlRuleConfig.getRelation());
//
//            List<JSONObject> listRule = new ArrayList<JSONObject>();
//            JSONArray fieldArray= JSONArray.parseArray(JSON.toJSONString(tDrlRuleConfig.getFieldList()));
//            JSONArray exArray= JSONArray.parseArray(JSON.toJSONString(tDrlRuleConfig.getExList()));
//            if (fieldArray != null) {
//                for(int i = 0; i<fieldArray.size(); i++) {
//                    listRule.add(fieldArray.getJSONObject(i));
//                }
//            }
//            if (exArray != null) {
//                for(int j = 0; j<exArray.size(); j++) {
//                    listRule.add(exArray.getJSONObject(j));
//                }
//            }
//            createRuleModel.setRuleList(listRule);
//
//            //生成规则内容
//            String rule = ruleUtils.createRule(num, createRuleModel, modelEntityList, warningInfo);
//            ruleUtils.load(rule);
//            tDrlRuleConfig.setContent(rule);
//
//            // 词条ID、计算表达式ID拼接
//            if (fieldList != null) {
//                String fieldJoin = StringUtils.join(fieldList.stream().map(TDrlNRuleFieldConfig::getFieldId).toArray(), ",");
//                tDrlRuleConfig.setFieldId(fieldJoin);
//            }
//            if (exList != null) {
//                String exJoin = StringUtils.join(exList.stream().map(TDrlNRuleExpressionConfig::getExPreID).toArray(), ",");
//                tDrlRuleConfig.setComEXId(exJoin);
//            }
//            tDrlRuleConfig.setCode("FIELD"+num);
//            tDrlRuleConfig.setType("1");
//
//            //保存规则
//            updateRow = this.ruleConfigCreat(tDrlRuleConfig);
//
//            //保存规则模式、词条、计算表达式表
//            if (modelEntityList != null) {
//                tDrlRuleModelConfigCreate(modelEntityList,null);
//            }
//            if (fieldList != null) {
//                tDrlRuleFieldConfigCreate(fieldList, tDrlRuleConfig);
//            }
//            if (exList != null) {
//                tDrlRuleEXConfigCreate(exList, tDrlRuleConfig);
//            }
//
//        }
//        return updateRow;
//    }
//
//    /**
//     * 根据词条id查询
//     * @param fieldId
//     * @return
//     */
//    private TDrlFieldConfig queryFiled(String fieldId) {
//        TDrlFieldConfig fieldConfig = new TDrlFieldConfig();
//        fieldConfig.setId(fieldId);
//        List<TDrlFieldConfig> fieldConfigList = dictionaryMapper.queryTdrlField(fieldConfig);
//        if(fieldConfigList.isEmpty()){
//            throw new ParamException("词条不存在");
//        }
//        return fieldConfigList.get(0);
//    }
//
//    /**
//     * 创建规则模式
//     * @param modelEntityList
//     */
//    private void tDrlRuleModelConfigCreate(List<ModelEntity> modelEntityList, String fieldId) {
//        int updateRuModRow = 0;
//
//        for (ModelEntity modelEntity : modelEntityList) {
//            Long id = idGenerator.snowflakeId();
//            updateRuModRow = ruleMapper.tDrlRuleModelConfigCreate(id, modelEntity.getFieldPath(), modelEntity.getOperationType(), modelEntity.getDescription(), fieldId);
//            if (updateRuModRow <= 0) {
//                logger.error(modelEntity.getValue() + "规则模式表保存失败");
//                throw new ParamException( modelEntity.getValue() + "规则模式表保存失败");
//            }
//        }
//    }
//
//    /**
//     * 创建规则词条
//     * @param ruleFieldConfigs
//     * @param tDrlRuleConfi
//     */
//    private void tDrlRuleFieldConfigCreate(List<TDrlNRuleFieldConfig> ruleFieldConfigs, TDrlRuleConfi tDrlRuleConfi) {
//        int updateRuFieldRow = 0;
//
//        for (TDrlNRuleFieldConfig tDrlNRuleFieldConfig : ruleFieldConfigs) {
//            tDrlNRuleFieldConfig.setId(String.valueOf(idGenerator.snowflakeId()));
//            tDrlNRuleFieldConfig.setRuleId(tDrlRuleConfi.getId());
//            updateRuFieldRow = ruleMapper.tDrlRuleFieldConfigCreate(tDrlNRuleFieldConfig);
//            if (updateRuFieldRow <= 0) {
//                logger.error(tDrlNRuleFieldConfig.getFieldCodePath() + "规则词条表保存失败");
//                throw new ParamException( tDrlNRuleFieldConfig.getFieldCodePath() + "规则词条表保存失败");
//            }
//        }
//    }
//
//    /**
//     * 创建规则计算表达式
//     * @param exList
//     */
//    private void tDrlRuleEXConfigCreate(List<TDrlNRuleExpressionConfig> exList, TDrlRuleConfi tDrlRuleConfi) {
//        int updateRuModRow = 0;
//
//        for (TDrlNRuleExpressionConfig ruleExpressionConfig : exList) {
//            ruleExpressionConfig.setId(String.valueOf(idGenerator.snowflakeId()));
//            ruleExpressionConfig.setRuleId(tDrlRuleConfi.getId());
//            updateRuModRow = ruleMapper.tDrlRuleEXConfigCreate(ruleExpressionConfig);
//            if (updateRuModRow <= 0) {
//                logger.error(ruleExpressionConfig.getExPreID() + "规则计算表达式表保存失败");
//                throw new ParamException( ruleExpressionConfig.getExPreID() + "规则计算表达式表保存失败");
//            }
//        }
//    }
//
//    /**
//     * 获取词条规则号
//     * @param code
//     * @return
//     */
//    public Long getNum (String code){
//        TDrlNCount tDrlNCount = new TDrlNCount();
//        tDrlNCount.setCode("FILELD");
//        tDrlNCount.setDescription("词条生成规则编码");
//        int count = 0;
//        try {
//            count = ruleMapper.tDrlCountUpdate(tDrlNCount);
//        } catch (Exception e){
//
//        }
//        if (count <= 0) {
//            throw new ParamException("词条创建规则时计数加1失败！");
//        }
//        Long num = tDrlNCount.getNum();
//        if (num == null) {
//            tDrlNCount.setId(String.valueOf(idGenerator.snowflakeId()));
//            ruleMapper.insertNCountCode(tDrlNCount);
//            num = 1L;
//        }
//        return num;
//    }
//
//    /**
//     * 处理模式字典数据
//     * @param modelEntityList
//     */
//    private void modelSetDictionary (List < ModelEntity > modelEntityList) {
//        if (null == modelEntityList) {
//            return;
//        }
//        for (ModelEntity modelEntity : modelEntityList) {
//            if (!StringUtils.isEmpty(modelEntity.getOperationType())) {
//                modelEntity.setDictionary(this.queryDictionary("4", modelEntity.getOperationType(), "运算符错误，在字典数据中无法找到！"));
//            } else {
//                modelEntity.setDictionary(new TDrlDictionary());
//            }
//        }
//    }
//
//    /**
//     * 处理关系字典数据
//     * @param createRuleModel
//     * @param relation
//     */
//    private void relationSetDictionary (CreateRuleModel createRuleModel, String relation) {
//        if (!StringUtils.isEmpty(relation)) {
//            createRuleModel.setTDrlDictionary(this.queryDictionary("5", relation, "运算符错误，在字典数据中无法找到！"));
//        } else {
//            createRuleModel.setTDrlDictionary(new TDrlDictionary());
//        }
//    }
//
//    /**
//     * 处理词条字典数据
//     * @param fieldList
//     */
//    private void fieldSetDictionary (List<TDrlNRuleFieldConfig> fieldList) {
//        if (null == fieldList) {
//            return;
//        }
//        for (TDrlNRuleFieldConfig tDrlNRuleFieldConfig : fieldList) {
//            if (!StringUtils.isEmpty(tDrlNRuleFieldConfig.getOperationType())) {
//                tDrlNRuleFieldConfig.setDictionary(this.queryDictionary("4", tDrlNRuleFieldConfig.getOperationType(), "运算符错误，在字典数据中无法找到！"));
//            } else {
//                tDrlNRuleFieldConfig.setDictionary(new TDrlDictionary());
//            }
//        }
//    }
//
//    /**
//     * 处理计算表达式字典数据
//     * @param exList
//     */
//    private void exPreSetDictionary (List<TDrlNRuleExpressionConfig> exList) {
//        if (null == exList) {
//            return;
//        }
//        for (TDrlNRuleExpressionConfig tDrlNRuleExpressionConfig : exList) {
//            if (!StringUtils.isEmpty(tDrlNRuleExpressionConfig.getOperationType())) {
//                tDrlNRuleExpressionConfig.setDictionary(this.queryDictionary("4", tDrlNRuleExpressionConfig.getOperationType(), "运算符错误，在字典数据中无法找到！"));
//            } else {
//                tDrlNRuleExpressionConfig.setDictionary(new TDrlDictionary());
//            }
//        }
//    }
//
//    /**
//     * 查询字典
//     * @param type
//     * @param code
//     * @return
//     */
//    public TDrlDictionary queryDictionary (String type, String code, String msg){
//        if(StringUtils.isEmpty(code)){
//            throw new ParamException("字典编码为空");
//        }
//        TDrlDictionary tDrlDictionary = new TDrlDictionary();
//        tDrlDictionary.setType(type);
//        tDrlDictionary.setCode(code);
//        List<TDrlDictionary> queryDictionaryList = ruleMapper.queryDictionary(tDrlDictionary);
//        if (queryDictionaryList.isEmpty()) {
//            throw new ParamException(msg);
//        }
//        return queryDictionaryList.get(0);
//    }
//}
